Problem

Creating, deleting, or editing one cohort costs time proportional to how many cohorts the project already holds, and that work runs inside the web request.

• Each such write runs warm_team_cohort_dependency_cache inline, through transaction.on_commit with no ATOMIC_REQUESTS.
• The warm loads every live cohort of the team from Postgres with full filters and does three to four Redis round trips per cohort.
• A create always takes that path: the new cohort's cache key does not exist yet, so it reads as "dependencies changed".
• The cost is independent of the request itself, so a project with many cohorts pays for all of them on every write.

Changes

• A cohort write now costs one or two Redis round trips and no extra Postgres reads. Nothing user-visible changes.
• _on_cohort_changed writes only the changed cohort's own keys and deletes the reverse lists of the cohorts it started or stopped referencing. DEL is idempotent, so concurrent writers cannot lose an update, and the next reader rebuilds the list.
• Delete paths take the old dependency set from the instance's own filters, so an expired cache key no longer leaves a dangling reverse entry.
• A read miss on dependents still warms the team, but the warm loads only filters and groups, writes with set_many, and never runs from a write path.
• The two key families move to a writer-only cache alias, cohort_dependencies, mirroring organization_access. The create path reads its own keys back in the same request, and a replica-lag miss would rescan the team.
• COHORT_DEPENDENCY_INCREMENTAL_MAINTENANCE (default on) falls back to the full warm. A wrong incremental update shows only as a shorter recalculation chain, which no dashboard surfaces, so a config flip has to beat a revert.
• get_cohort_dependents no longer filters the team lookup on deleted, so a soft-deleted cohort with live dependents stops caching an empty list for a week.
• New metrics: posthog_cohort_dependency_maintenance_total{operation,path} and the histogram posthog_cohort_dependency_warm_cohorts_scanned.
• Supersedes fix(cohorts): batch the dependency cache warm's Redis calls #94251, which batched the warm's Redis calls but kept the warm on every save.

How did you test this code?

• Existing test_dependencies.py cases pass with one helper reordered (the raw reverse-key assertion moves after the read that rebuilds it) and the TTL test rewritten for set_many.
• New tests, each named for the regression it catches: a create on a team with existing cohorts issues no cohort table read and no warm; a create with no references writes only its own keys; a create with a reference invalidates the target's reverse list; a hard delete with the dependencies key absent still invalidates; soft delete then restore re-adds the reverse edge; a save without definition fields skips maintenance; the warm uses batched writes only; the reverse map spans batches; the kill switch restores the full warm.
• Also run locally: test_cohort_update_recalculated_after_caching, the dependency-chain tests in test_calculate_cohort.py, the dependency tests in test_util.py, hogli lint:tach, repo-wide mypy, and hogli ci:preflight.
• Not run: the full test_cohort.py and test_calculate_cohort.py suites.

Docs update

No.